import systemdemo from '@/components/ts/systemdemo'
import {df_from_excel} from '@/components/ts/EtPandas'
import {storeToRefs} from 'pinia'
import {useCCPPStore} from '@/store'
import lodash from 'lodash'

const store = useCCPPStore()

const printToTerm = store.printToTerm

interface ParameterInstance {
    name: string;

    [key: string]: any;
}

export function get_correct_title(correct_paras: (string | ParameterInstance)[]) {
    /**
     * 根据修正参数项生成修正曲线表的列标题
     */
    let res = []
    for (let i of correct_paras) {
        const isString = i instanceof String
        const name = isString ? i : (i as ParameterInstance).name
        // console.log(i)
        if (name === '大气压力') {
            if (isString) {
                res.push(...[
                    '大气压力_kPa', '功率修正系数', '大气压力_kPa', '热耗率修正系数', ''
                ])
            } else if ((i as ParameterInstance).x === '大气压力变化量') {
                res.push(...[
                    '大气压力变化量_kPa',
                    '功率修正系数',
                    '大气压力变化量_kPa',
                    '热耗率修正系数',
                    ''
                ])
            } else {
                res.push(...[
                    '大气压力_kPa', '功率修正系数', '大气压力_kPa', '热耗率修正系数', ''
                ])
            }
        } else if (name === '大气温度') {
            if (isString) {
                res.push(...[
                    '大气温度_℃', '功率修正系数', '大气温度_℃', '热耗率修正系数', ''
                ])
            } else if (lodash.includes((i as ParameterInstance).x, '大气温度变化量')) {
                res.push(...[
                    '大气温度变化量_℃',
                    '功率修正系数',
                    '大气温度变化量_℃',
                    '热耗率修正系数',
                    ''
                ])
            } else {
                res.push(...[
                    '大气温度_℃', '功率修正系数', '大气温度_℃', '热耗率修正系数', ''
                ])
            }
        } else if (name === '环境相对湿度') {
            if (isString) {
                res.push(...[
                    '环境温度_℃', '环境相对湿度_%', '功率修正系数', '环境温度_℃', '环境相对湿度_%', '热耗率修正系数', ''
                ])
            } else if ((i as ParameterInstance).x === '环境湿度变化量') {
                res.push(...[
                    '环境温度_℃',
                    '环境相对湿度变化量_%',
                    '功率修正系数',
                    '环境温度_℃',
                    '环境相对湿度变化量_%',
                    '热耗率修正系数',
                    ''
                ])
            } else {
                res.push(...[
                    '环境温度_℃', '环境相对湿度_%', '功率修正系数', '环境温度'])
            }
        } else if (name === '天然气热值' || name === '燃料气低位热值') {
            if (isString) {
                res.push(...[
                    'C/H', '燃料气热值_kJ/kg', '功率修正系数', 'C/H', '燃料气热值_kJ/kg', '热耗率修正系数', ''
                ])
            } else if ((i as ParameterInstance).x === '燃料气热值变化量') {
                res.push(...[
                    'C/H',
                    '燃料气热值变化量_kJ/kg',
                    '功率修正系数',
                    'C/H',
                    '燃料气热值变化量_kJ/kg',
                    '热耗率修正系数',
                    ''
                ])
            } else {
                res.push(...[
                    'C/H', '燃料气热值_kJ/kg', '功率修正系数', 'C/H', '燃料气热值_kJ/kg', '热耗率修正系数', ''
                ])
            }
        } else if (name === '背压') {
            res.push(...[
                '背压_kPa', '功率修正系数', '背压_kPa', '热耗率修正系数', ''
            ])
        } else if (name === '循环水温度对功率') {
            if (isString) {
                res.push(...[
                    '循环水温度偏差_K', '功率修正量_MW', ''
                ])
            } else if ((i as ParameterInstance).x === '循环水温度值' && (i as ParameterInstance).y === '加法修正量') {
                res.push(...[
                    '循环水温度_℃', '功率修正量_MW', ''
                ])
            } else {
                res.push(...[
                    '循环水温度偏差_K', '功率修正量_MW', ''
                ])
            }
        } else if (name === '循环水流量对功率') {
            if (isString) {
                res.push(...[
                    '循环水流量_t/h', '功率修正量_MW', ''
                ])
            } else if ((i as ParameterInstance).x === '循环水流量值' && (i as ParameterInstance).y === '加法修正量') {
                res.push(...[
                    '循环水流量_t/h', '功率修正量_MW', ''
                ])
            } else if ((i as ParameterInstance).x === '循环水流量变化量' && (i as ParameterInstance).y === '加法修正量') {
                res.push(...[
                    '循环水流量变化量_t/h', '功率修正量_MW', ''
                ])
            } else {
                res.push(...[
                    '循环水流量偏差百分比_%', '功率修正量_MW', ''
                ])
            }
        } else if (name === '燃料气温度') {
            if (isString) {
                res.push(...[
                    '燃料气温度_℃', '功率修正系数', '燃料气温度_℃', '热耗率修正系数', ''
                ])
            } else if ((i as ParameterInstance).x === '燃料气温度变化量') {
                res.push(...[
                    '燃料气温度变化量_℃',
                    '功率修正系数',
                    '燃料气温度变化量_℃',
                    '热耗率修正系数',
                    ''
                ])
            } else {
                res.push(...[
                    '燃料气温度_℃', '功率修正系数', '燃料气温度_℃', '热耗率修正系数', ''
                ])
            }
        } else if (name === '系统不明泄漏量对功率' || name === '系统泄漏量对功率') {
            res.push(...[
                '不明漏量_t/h', '功率修正量_MW', ''
            ])
        } else if (name === '发电机转速') {
            if (isString) {
                res.push(...[
                    '温度_℃', '转速变化量_rpm', '功率修正系数', '温度_℃', '转速变化量_rpm', '热耗率修正系数', ''
                ])
            } else if ((i as ParameterInstance).x === '发电机转速变化量') {
                res.push(...[
                    '温度_℃', '转速变化量_rpm', '功率修正系数', '温度_℃', '转速变化量_rpm', '热耗率修正系数', ''
                ])
            } else {
                res.push(...[
                    '温度_℃', '发电机转速_rpm', '功率修正系数', '温度_℃', '发电机转速_rpm', '热耗率修正系数', ''
                ])
            }
        } else if (name === '燃机发电机频率') {
            res.push(...[
                '燃机发电机频率_Hz', '功率修正系数', '燃机发电机频率_Hz', '热耗率修正系数', ''
            ])
        } else if (name === '汽机发电机频率') {
            res.push(...[
                '汽机发电机频率_Hz', '功率修正系数', '汽机发电机频率_Hz', '热耗率修正系数', ''
            ])
        } else if (name === '补水率') {
            res.push(...[
                '补水率', '功率修正系数', '补水率', '热耗率修正系数', ''
            ])
        } else if (name === '燃机发电机功率因数') {
            res.push(...[
                '燃机功率_MW', '燃机发电机功率因数', '效率变化', ''
            ])
        } else if (name === '燃机发电机功率因数对功率加法修正') {
            res.push(...[
                '燃机功率_MW', '燃机发电机功率因数', '功率修正量_MW', ''
            ])
        } else if (name === '汽机发电机功率因数对功率加法修正') {
            res.push(...[
                '汽机功率_MW', '汽机发电机功率因数', '功率修正量_MW', ''
            ])
        } else if (name === '发电机功率因数对功率加法修正') {
            res.push(...[
                '联合循环总功率_MW', '发电机功率因数', '功率修正量_MW', ''
            ])
        } else if (name === '汽机发电机功率因数') {
            res.push(...[
                '汽机功率_MW', '汽机发电机功率因数', '效率变化', ''
            ])
        } else if (name === '燃机发电机氢压') {
            res.push(...[
                '燃机功率_MW', '燃机发电机氢压_MPa', '效率变化', ''
            ])
        } else if (name === '汽机发电机氢压') {
            res.push(...[
                '燃机功率_MW', '燃机发电机氢压_MPa', '效率变化', ''
            ])
        }
    }
    return res
}

// 定义修正曲线标题模式及对应的名称
const curvePatterns = [
    // 大气压力
    {pattern: ['大气压力_kPa', '功率修正系数'], name: '大气压力_功率'},
    {pattern: ['大气压力变化量_kPa', '功率修正系数'], name: '大气压力_功率'},
    {pattern: ['大气压力_kPa', '热耗率修正系数'], name: '大气压力_热耗率'},
    {pattern: ['大气压力变化量_kPa', '热耗率修正系数'], name: '大气压力_热耗率'},

    // 大气温度
    {pattern: ['大气温度_℃', '功率修正系数'], name: '大气温度_功率'},
    {pattern: ['大气温度变化量_℃', '功率修正系数'], name: '大气温度_功率'},
    {pattern: ['大气温度_℃', '热耗率修正系数'], name: '大气温度_热耗率'},
    {pattern: ['大气温度变化量_℃', '热耗率修正系数'], name: '大气温度_热耗率'},

    // 环境温度和相对湿度
    {pattern: ['环境温度_℃', '环境相对湿度_%', '功率修正系数'], name: 'RH_功率'},
    {pattern: ['环境温度_℃', '环境相对湿度变化量_%', '功率修正系数'], name: 'RH_功率'},
    {pattern: ['环境温度_℃', '环境相对湿度_%', '热耗率修正系数'], name: 'RH_热耗率'},
    {pattern: ['环境温度_℃', '环境相对湿度变化量_%', '热耗率修正系数'], name: 'RH_热耗率'},

    // 天然气热值
    {pattern: ['C/H', '天然气热值_kJ/kg', '功率修正系数'], name: 'LHV_功率'},
    {pattern: ['C/H', '燃料气热值变化量_kJ/kg', '功率修正系数'], name: 'LHV_功率'},
    {pattern: ['C/H', '天然气热值_kJ/kg', '热耗率修正系数'], name: 'LHV_热耗率'},
    {pattern: ['C/H', '燃料气热值变化量_kJ/kg', '热耗率修正系数'], name: 'LHV_热耗率'},

    {pattern: ['燃料气温度变化量_℃', '功率修正系数'], name: '燃料气温度_功率'},
    {pattern: ['燃料气温度变化量_℃', '热耗率修正系数'], name: '燃料气温度_热耗率'},

    // 背压
    {pattern: ['背压_kPa', '功率修正系数'], name: '背压_功率'},
    {pattern: ['背压_kPa', '热耗率修正系数'], name: '背压_热耗率'},

    {pattern: ['循环水温度偏差_K', '功率修正量_MW'], name: '循环水温度_功率'},

    {pattern: ['循环水流量偏差百分比_%', '功率修正量_MW'], name: '循环水流量_功率'},

    {pattern: ['温度_℃', '发电机转速_rpm', '功率修正系数'], name: '发电机转速_功率'},
    {pattern: ['温度_℃', '发电机转速_rpm', '热耗率修正系数'], name: '发电机转速_热耗率'},

    // 燃机发电机频率
    {pattern: ['燃机发电机频率_Hz', '功率修正系数'], name: '燃机频率_功率'},
    {pattern: ['燃机发电机频率_Hz', '热耗率修正系数'], name: '燃机频率_热耗率'},

    // 汽机发电机频率
    {pattern: ['汽机发电机频率_Hz', '功率修正系数'], name: '汽机频率_功率'},
    {pattern: ['汽机发电机频率_Hz', '热耗率修正系数'], name: '汽机频率_热耗率'},

    // 补水率
    {pattern: ['补水率', '功率修正系数'], name: '补水率_功率'},
    {pattern: ['补水率', '热耗率修正系数'], name: '补水率_热耗率'},

    {pattern: ['不明漏量_t/h', '功率修正量_MW'], name: '补水率_热耗率'},

    // 燃机功率和功率因数
    {pattern: ['燃机功率_MW', '燃机发电机功率因数', '效率变化'], name: '燃机功率因数_效率'},

    // 汽机功率和功率因数
    {pattern: ['汽机功率_MW', '汽机发电机功率因数', '效率变化'], name: '汽机功率因数_效率'},

    // 燃机功率和氢压
    {pattern: ['燃机功率_MW', '燃机发电机氢压_MPa', '效率变化'], name: '燃机氢压_效率'}
] as const

export type CurveNames = typeof curvePatterns[number]['name']

export type CurveRegion = Map<CurveNames, {
    sheet_name: string,
    startRow: number,
    endRow: number,
    startCol: number,
    endCol: number
}>;

export const load_curves_sheet = (sheet_name: string = '修正曲线'): CurveRegion => {
    if (systemdemo.exist_sheet(sheet_name)) {
        const df = df_from_excel(sheet_name, 1, 1, true, false)

        // 定义一个函数来找到每个修正曲线数据区域的起始和结束位置
        const findCurveRegions = (df) => {
            let regions = new Map() // 使用 Map 以便通过 name 查找
            const indices = df.index

            // 查找匹配的曲线区域
            for (let i = 0; i < indices.length; i++) {
                for (const patternObj of curvePatterns) {
                    const pattern = patternObj.pattern
                    const name = patternObj.name

                    // 检查是否有足够的行来匹配模式
                    if (i + pattern.length > indices.length) {
                        continue
                    }

                    // 检查模式是否匹配
                    let match = true
                    for (let j = 0; j < pattern.length; j++) {
                        if (indices[i + j] !== pattern[j]) {
                            match = false
                            break
                        }
                    }

                    // 如果匹配，记录区域
                    if (match) {
                        // 计算实际的结束列数
                        let endCol = 1 // 至少有一列数据

                        // 检查每一列直到遇到连续的空值
                        for (let col = 1; col <= df.columns.length; col++) {
                            let hasData = false

                            // 检查当前列在模式行中是否有数据
                            for (let rowOffset = 0; rowOffset < pattern.length; rowOffset++) {
                                const rowIndex = i + rowOffset
                                if (rowIndex < df.index.length && col - 1 < df.columns.length) {
                                    const value = df.iloc(rowIndex, col - 1)
                                    if (value !== null && value !== undefined && value !== '') {
                                        hasData = true
                                        break
                                    }
                                }
                            }

                            if (hasData) {
                                endCol = col
                            } else {
                                // 如果连续几列都没有数据，就认为是结束
                                let emptyCols = 0
                                for (let nextCol = col; nextCol < Math.min(col + 3, df.columns.length + 1); nextCol++) {
                                    let nextHasData = false
                                    for (let rowOffset = 0; rowOffset < pattern.length; rowOffset++) {
                                        const rowIndex = i + rowOffset
                                        if (rowIndex < df.index.length && nextCol - 1 < df.columns.length) {
                                            const value = df.iloc(rowIndex, nextCol - 1)
                                            if (value !== null && value !== undefined && value !== '') {
                                                nextHasData = true
                                                break
                                            }
                                        }
                                    }
                                    if (!nextHasData) {
                                        emptyCols++
                                    } else {
                                        break
                                    }
                                }

                                // 如果连续3列都没有数据，则认为是结束
                                if (emptyCols >= 3) {
                                    break
                                }
                            }
                        }

                        // 检查区域是否为空（只有标题没有数据）
                        let isEmpty = true
                        // 检查除了标题行之外的行是否有数据
                        for (let rowOffset = 1; rowOffset < pattern.length; rowOffset++) { // 从第二行开始检查（跳过标题行）
                            const rowIndex = i + rowOffset
                            for (let col = 1; col <= endCol; col++) {
                                if (rowIndex < df.index.length && col - 1 < df.columns.length) {
                                    const value = df.iloc(rowIndex, col - 1)
                                    if (value !== null && value !== undefined && value !== '') {
                                        isEmpty = false
                                        break
                                    }
                                }
                            }
                            if (!isEmpty) break
                        }

                        // 如果区域为空，弹出警告
                        if (isEmpty) {
                            alert(`警告: 修正曲线 "${name}" 区域为空，请检查数据！`)
                        }

                        regions.set(name, {
                            sheet_name: sheet_name,
                            name: name,
                            pattern: pattern,
                            startRow: i + 1, // Excel行号从1开始
                            endRow: i + pattern.length,
                            startCol: 2, // 数据从B列开始（第2列）
                            endCol: endCol + 1 // 结束列也加1
                        })

                        // 跳过已匹配的行
                        i += pattern.length - 1
                        break
                    }
                }
            }

            return regions
        }

        const curveRegions = findCurveRegions(df)
        console.log('修正曲线数据区域:', curveRegions)
        printToTerm(`修正曲线数据区域: ${curveRegions}`)

        return curveRegions
    } else {
        alert(`未找到【${sheet_name}】工作表，请先生成【${sheet_name}】工作表`)
        return null
    }
}

export default {
    get_correct_title
}